package org.dppc.fine4j.kit;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.ClassUtils;

/**
 * Class工具类
 * 
 * @author maomh
 *
 */
public class ClassKit extends ClassUtils {
	
	/**
	 * 获取类加载器实例
	 * 
	 * @return
	 */
	public static ClassLoader getClassLoader() {
		return Thread.currentThread().getContextClassLoader();
	}
	
	
	/**
	 * 载入某个类
	 * 
	 * @param className 类名
	 * @param initialize 是否初始化
	 * @return
	 */
	public static Class<?> loadClass(String className, boolean initialize) {
		Class<?> clazz =null;
		try {
			clazz =Class.forName(className, initialize, getClassLoader());
		} catch (Throwable t) {
			//t.printStackTrace();
		}
		return clazz;
	}
	
	
	/**
	 * 初始化某个类
	 * 
	 * @param clazz
	 */
	public static void initClass(Class<?> clazz) {
		loadClass(clazz.getName(), true);
	}
	
	
	/**
	 * 初始化多个类
	 * 
	 * @param classes
	 */
	public static void initClasses(Class<?>[] classes) {
		if (classes != null && classes.length > 0) {
			for (Class<?> clazz : classes) {
				loadClass(clazz.getName(), true);
			}
		}
	}
	
	
	/**
	 * 判断两个类是否有继承关系，当然，若一致也会返回true
	 * 
	 * @param superClass
	 * @param subClass
	 * @return
	 */
	public static boolean isInhritance(Class<?> superClass, Class<?> subClass) {
		return superClass.isAssignableFrom(subClass);
	}
	
	
	/**
	 * 获取所有的超类
	 * 
	 * @param clazz 类型对象
	 * @param recursive 是否递归遍历
	 * @return
	 */
	public static Class<?>[] getAllSupers(Class<?> clazz, boolean recursive) {
		List<Class<?>> supers =new ArrayList<Class<?>>();
		ClassKit.getAllInterfaces(clazz, supers, recursive);
		ClassKit.getAllExtends(clazz, supers, recursive);
		Class<?>[] temp =new Class<?>[supers.size()];
		return supers.toArray(temp);
	}
	
	
	/**
	 * 获取这个类型的所有接口（由implements标识）
	 * 
	 * @param clazz
	 * @param recursive 是否递归遍历
	 * @return
	 */
	public static Class<?>[] getAllInterfaces(Class<?> clazz, boolean recursive) {
		List<Class<?>> interfaces =new ArrayList<Class<?>>();
		ClassKit.getAllInterfaces(clazz, interfaces, recursive);
		Class<?>[] temp =new Class<?>[interfaces.size()];
		return interfaces.toArray(temp);
	}
	
	
	/**
	 * 获取这个类的所有超类（由extends标识）
	 * 
	 * @param clazz
	 * @param recursive
	 * @return
	 */
	public static Class<?>[] getAllExtends(Class<?> clazz, boolean recursive) {
		List<Class<?>> exts =new ArrayList<Class<?>>();
		ClassKit.getAllInterfaces(clazz, exts, recursive);
		Class<?>[] temp =new Class<?>[exts.size()];
		return exts.toArray(temp);
	}
	
	
	// 递归遍历clazz的所有接口
	private static void getAllInterfaces(Class<?> clazz, List<Class<?>> interfaces, boolean recursive) {
		Class<?>[] intfClasses =clazz.getInterfaces();
		if (intfClasses != null && intfClasses.length > 0) {
			for (Class<?> intfClass : intfClasses) {
				// 若supers还没有这个接口
				if (!interfaces.contains(intfClass)) {
					interfaces.add(intfClass);
					// 若需要递归
					if (recursive) {
						getAllInterfaces(intfClass, interfaces, recursive);
					}
				}
			}
		}
	}

	
	// 递归遍历clazz的所有超类
	private static void getAllExtends(Class<?> clazz, List<Class<?>> exts, boolean recursive) {
		// 超类
		Class<?> abclass =clazz.getSuperclass();
		if (abclass != null && !exts.contains(abclass)) {
			exts.add(abclass);
			// 若需要递归
			if (recursive) {
				getAllExtends(abclass, exts ,recursive);
			}
		}
	}
}
